#-*- coding: utf8 -*-

def game(player_1='metralha', player_2='metralha'):
    
    from random import randint
    from os import sep
    import pygame
    from pygame.locals import *
    from sys import exit
    from math import sin, cos, radians
    from submain import is_over
    
    pygame.init()
    
    screensize = (900, 600)
    screen = pygame.display.set_mode(screensize,0 ,32)
    
    #CARREGAMENTO DAS IMAGENS
    agulha_1 = pygame.image.load('images'+sep+'cenarios'+sep+'agulha.png').convert_alpha()
    contador_1 = pygame.image.load('images'+sep+'cenarios'+sep+'contador.png').convert_alpha()
    ball_1 = pygame.image.load('images'+sep+'bolas'+sep+'ball_'+player_1+'.png').convert_alpha()
    ball_2 = pygame.image.load('images'+sep+'bolas'+sep+'ball_'+player_2+'.png').convert_alpha()
    cenario = pygame.image.load('images'+sep+'cenarios'+sep+'cenario_%i.png' %randint(1,5)).convert()
    bloco_1 = pygame.image.load('images'+sep+'blocos'+sep+'bloco_1.png').convert()
    bloco_2 = pygame.image.load('images'+sep+'blocos'+sep+'bloco_2.png').convert()
    bloco_3 = pygame.image.load('images'+sep+'blocos'+sep+'bloco_3.png').convert()
    bloco_4 = pygame.image.load('images'+sep+'blocos'+sep+'bloco_4.png').convert()
    base_1 = pygame.image.load('images'+sep+'canhoes'+sep+player_1+'_down.png').convert_alpha()
    topo_1 = pygame.image.load('images'+sep+'canhoes'+sep+player_1+'_up.png').convert_alpha()
    base_2 = pygame.image.load('images'+sep+'canhoes'+sep+player_2+'_down.png').convert_alpha()
    topo_2 = pygame.image.load('images'+sep+'canhoes'+sep+player_2+'_up.png').convert_alpha()
    explosao_1 =  pygame.image.load('images'+sep+'explosao'+sep+'1.png').convert_alpha()
    explosao_2 =  pygame.image.load('images'+sep+'explosao'+sep+'2.png').convert_alpha()
    explosao_3 =  pygame.image.load('images'+sep+'explosao'+sep+'3.png').convert_alpha()
    explosao_4 =  pygame.image.load('images'+sep+'explosao'+sep+'4.png').convert_alpha()
    explosao_5 =  pygame.image.load('images'+sep+'explosao'+sep+'5.png').convert_alpha()
    preparar = pygame.image.load('images'+sep+'avisos'+sep+'preparar.png').convert_alpha()
    apontar = pygame.image.load('images'+sep+'avisos'+sep+'apontar.png').convert_alpha()
    fogo = pygame.image.load('images'+sep+'avisos'+sep+'fogo.png').convert_alpha()
    
    agulha_2 = pygame.transform.flip(agulha_1, True, False)
    contador_2 = pygame.transform.flip(contador_1, True, False)
    base_2 = pygame.transform.flip(base_2, True, False)
    topo_2 = pygame.transform.flip(topo_2, True, False)
    fonte = pygame.font.Font('images'+sep+'army_wd.TTF', 60)
    player_1_win, player_2_win = False, False
    
    quebra_bloco = pygame.mixer.Sound('sounds'+sep+'quebra_bloco.wav')
    explosao_canhao = pygame.mixer.Sound('sounds'+sep+'explosao_canhao.wav')
    lanca_bola = pygame.mixer.Sound('sounds'+sep+'lanca_bola.wav')
    start = pygame.mixer.Sound('sounds'+sep+'start.wav')
    
    explosao_imgs = [explosao_1, explosao_2, explosao_3, explosao_4, explosao_5]
    lista_blocos =[bloco_1, bloco_2, bloco_3, bloco_4]
    imgs_inicio = [preparar, apontar, fogo]
    
    clock = pygame.time.Clock()
    
    matriz_inicio, matriz_centro, matriz_fim = [],[],[] 
    
    #CRIA A MATRIZ DE BLOCOS DO LADO ESQUERDO
    for linha in range(randint(2,8)):
        matriz_inicio.append([])
        for bloco in range(7):
            matriz_inicio[linha].append([lista_blocos[randint(0,3)], (30*bloco, 570-30*linha)])
    altura_blocos_1 = 570-30*linha
    
    #CRIA A MATRIZ CENTRAL DE BLOCOS
    x = 210
    for coluna in range(16):
        matriz_centro.append([])
        y=570
        for bloco in range(randint(1,15)):
            matriz_centro[coluna].append([lista_blocos[randint(0,3)], (x,y)])
            y-=30
        x+=30

    #CRIA A MATRIZ DE BLOCOS DO LADO DIREITO
    for linha in range(randint(2,8)):
        matriz_fim.append([])
        for bloco in range(7):
            matriz_fim[linha].append([lista_blocos[randint(0,3)], (23*30+30*bloco, 570-30*linha)])
    altura_blocos_2 = 570-30*linha
    
    posicao_p1 = 50
    posicao_p2 = 790
    movimento = True
    vel_bola = 20
    vel = 0
    go = True
    p1_time = True
    p2_time = False
    primeira_rodada = True
    explosao = False
    abertura = True
    
    width_canhao,height_canhao = 55, 45
    width_base, height_base = base_1.get_size()
    width_ball = ball_1.get_width()
    sprite_rotacao_1, sprite_rotacao_2 = 0. , 0.
    sprite_rotacao_speed = 180. # GRAUS POR SEGUNDO
    tempo_corrido = 0
    y_bola = 0
    lancamento = False
    
    index_begin_1 = 0
    index_begin_2 = 0
    index_end_1 = 7
    index_end_2 = 7
    
    lim_begin_1 = 2
    lim_end_1 = 210 - width_canhao
    lim_begin_2 = 712
    lim_end_2 = 900 - width_base -2
    
    while True:
        
        if abertura:
            for img in imgs_inicio:
                screen.fill((0,25,25))
                screen.blit(img, (900/2 - img.get_width()/2, 600/2-img.get_height()/2))
                pygame.display.update()
                if img == imgs_inicio[2]:
                    start.play(0)
                pygame.time.wait(1000)
                
            abertura = False
        
        for bloco in range(index_begin_1,int(posicao_p1/30)):
            if matriz_inicio[-1][bloco]==0:
                lim_begin_1 = 30*(bloco+1)+2
                index_begin_1 = bloco+1
        for bloco in range(int(posicao_p1/30),index_end_1):
            if matriz_inicio[-1][bloco]==0:
                lim_end_1 -= 30*(index_end_1-bloco)
                index_end_1 = bloco
                
        # 23 É O NÚMERO DE COLUNAS DE BLOCOS QUE TEM ANTES DE COMEÇAR A ÚLTIMA MATRIZ DE BLOCOS
        for bloco in range(index_begin_2,int(posicao_p2/30)-23):
            if matriz_fim[-1][bloco]==0:
                lim_begin_2 = 30*(bloco+1)+712
                index_begin_2 = bloco
        for i in range(int(posicao_p2/30)-23,index_end_2):
            if matriz_fim[-1][bloco]==0:
                lim_end_2 -= 30*(index_end_2-bloco)
                index_end_2 = bloco

        pressed_keys = pygame.key.get_pressed()
        for event in pygame.event.get():
            if event.type==QUIT:
                exit()
                
        move_x = 0
        direcao_rotacao = 0
        if movimento:
            if pressed_keys[K_ESCAPE]:
                return
            elif pressed_keys[K_LEFT]:
                move_x = -1
            elif pressed_keys[K_RIGHT]:
                move_x = +1
            elif pressed_keys[K_UP]:
                direcao_rotacao = +1.0
            elif pressed_keys[K_DOWN]:
                direcao_rotacao = -1.0
            
            if event.type == KEYDOWN:
                if event.key == K_SPACE:
                    try:
                        y_bola = y_base_1
                        tempo_corrido = 0
                        vel = +2
                        go = False
                    except:
                        None
            elif event.type == KEYUP:
                if event.key == K_SPACE:
                    vel = 0
                    go = True
                    lancamento = True
                    if tempo_corrido==0:
                        lanca_bola.play(0)
        if vel_bola >= 122:
            vel_bola = 122.5
        else:
            vel_bola += vel

        tempo_passado = clock.tick(50)
        tempo_passado_seg = tempo_passado/1000.0
        
        screen.blit(cenario, (0,0))
        screen.blit(contador_1, (5,5))
        screen.blit(contador_2, (820,5))
        # MOSTRA NA TELA TODOS OS ELEMENTOS DA matriz_inicio
        for linha in matriz_inicio:
            for bloco in linha:
                try:
                    screen.blit(bloco[0], (bloco[1][0],bloco[1][1]))
                except TypeError:
                    None
        
        # DADOS DO LANÇAMENTO DA BOLA
        if p1_time and p2_time==False and explosao==False:
            
            # VERIFICAÇÃO DOS LIMITES DE MOVIMENTAÇÃO DO PLAYER 1
            posicao_p1 += move_x
            if posicao_p1 <= lim_begin_1:
                posicao_p1 = lim_begin_1
            elif posicao_p1 >= lim_end_1:
                posicao_p1 = lim_end_1
            
            #MOSTRAR TOPO DO CANHÃO
            y_topo_1 = altura_blocos_1-height_base-5
            x_topo_1 = posicao_p1-27
            
            topo_rotacionado = pygame.transform.rotate(topo_1, sprite_rotacao_1)
            width_topo_1, height_topo_1 = topo_rotacionado.get_size()
            posicao_topo = (x_topo_1-width_topo_1/2+45, y_topo_1-height_topo_1/2+15)
            
            graus = radians(sprite_rotacao_1)
            vy = vel_bola*sin(graus)
            vx = vel_bola*cos(graus)
            x_bola = posicao_topo[0]+width_topo_1/2-width_ball/2
            
            if y_bola <= 630 and lancamento and go:
                tempo_corrido +=0.1
                s = vx*tempo_corrido
                h = vy*tempo_corrido + (-10*tempo_corrido**2)/2
                y_bola = y_base_1-h-5
                x_bola += s
                screen.blit(ball_1, (x_bola, y_bola))
                movimento = False
            else:
                if lancamento and go and movimento == False:
                    vel_bola = 20
                    p1_time = False
                    p2_time = True
                
                movimento, lancamento = True, False
                sprite_rotacao_1 += direcao_rotacao * sprite_rotacao_speed * tempo_passado_seg
            
            agulha_rotacionada_1 = pygame.transform.rotate(agulha_1, (vel_bola-20)*1.75)
            width_agulha_1, height_agulha_1 = agulha_rotacionada_1.get_size()
            posicao_agulha = (-30-width_agulha_1/2+38.5, 33.5-height_agulha_1/2+38.5)
            
        y_base_1 = altura_blocos_1-height_base
        try:
            screen.blit(topo_rotacionado, posicao_topo)
            screen.blit(base_1,(posicao_p1,y_base_1))
        except:
            explosao_canhao.play(0)
            screen.blit(explosao_imgs[4], (posicao_p1-25,y_base_1))
        screen.blit(agulha_rotacionada_1, posicao_agulha)
        
        # MOSTRA NA TELA TODOS OS ELEMENTOS DA matriz_centro
        for coluna in matriz_centro:
            for bloco in coluna:
                screen.blit(bloco[0], (bloco[1][0], bloco[1][1]))
        
        # MOSTRA NA TELA TODOS OS ELEMENTOS DA matriz_fim
        for linha in matriz_fim:
            for bloco in linha:
                try:
                    screen.blit(bloco[0], (bloco[1][0],bloco[1][1]))
                except TypeError:
                    None
        
        if p1_time==False and p2_time and explosao== False:
            primeira_rodada = False
            posicao_p2 += move_x
            # VERIFICAÇÃO DOS LIMITES DE MOVIMENTAÇÃO DO PLAYER 2
            if posicao_p2 <= lim_begin_2:
                posicao_p2 = lim_begin_2
            elif posicao_p2 >= lim_end_2:
                posicao_p2 = lim_end_2
            
            #MOSTRAR TOPO DO CANHÃO
            x_topo_2 = posicao_p2-31
            topo_rotacionado_2 = pygame.transform.rotate(topo_2, -(sprite_rotacao_2))
            width_topo_2, height_topo_2 = topo_rotacionado_2.get_size()
            posicao_topo_2 = (x_topo_2-width_topo_2/2+45, y_topo_2-height_topo_2/2+15)
            graus = radians(sprite_rotacao_2)
            vy = vel_bola*sin(graus)
            vx = vel_bola*cos(graus)
            x_bola = posicao_topo_2[0]+width_topo_2/2-width_ball/2
            
            if y_bola <= 630 and lancamento and go:
                
                tempo_corrido +=0.1
                s = vx*tempo_corrido
                h = vy*tempo_corrido + (-10*tempo_corrido**2)/2
                y_bola = y_base_2-h-5
                x_bola -= s
                screen.blit(ball_2, (x_bola, y_bola))
                movimento = False
            else:
                if lancamento and go and movimento == False:
                    vel_bola = 20
                    p1_time = True
                    p2_time = False
                movimento, lancamento = True, False
                sprite_rotacao_2 += direcao_rotacao * sprite_rotacao_speed * tempo_passado_seg
            
            agulha_rotacionada_2 = pygame.transform.rotate(agulha_2, -((vel_bola-20)*1.75))
            width_agulha_2, height_agulha_2 = agulha_rotacionada_2.get_size()
            posicao_agulha_2 = (852-width_agulha_2/2+38.5, 33.5-height_agulha_2/2+38.5)
            
        if primeira_rodada:
            #MOSTRAR TOPO DO CANHÃO
            y_topo_2 = altura_blocos_2-height_base-5
            x_topo_2 = posicao_p2-31
            screen.blit(topo_2, (x_topo_2, y_topo_2-30))
            screen.blit(agulha_2, (852, 34))
        else:
            try:
                screen.blit(agulha_rotacionada_2, posicao_agulha_2)
                screen.blit(topo_rotacionado_2, posicao_topo_2)
            except:
                None
                
        #MOSTRAR BASE DO CANHÃO
        y_base_2 = altura_blocos_2-height_base
        try:
            screen.blit(base_2,(posicao_p2,y_base_2))
        except:
            explosao_canhao.play(0)
            screen.blit(explosao_imgs[4], (posicao_p2-25,y_base_2))
            pygame.display.flip()
            
        if player_1_win:
            texto = fonte.render("JOGADOR 1 VENCEU!", 1, (0, 40, 20))
            texto_tam = texto.get_size()
            screen.blit(texto, (900/2 - texto_tam[0]/2, 600/2 - texto_tam[1]/2))
            pygame.display.flip()
            pygame.time.wait(2500)
            return
        elif player_2_win:
            texto = fonte.render("JOGADOR 2 VENCEU!", 1, (0, 40, 20))
            texto_tam = texto.get_size()
            screen.blit(texto, (900/2 - texto_tam[0]/2, 600/2 - texto_tam[1]/2))
            pygame.display.flip()
            pygame.time.wait(2500)
            return
                
        # VERIFICAÇÃO DA COLISÃO DA BOLA COM BLOCOS E CANHÕES
        if movimento==False and explosao==False:
            cont = -1
            for linha in matriz_inicio:
                cont_bloco=-1
                cont+=1
                for bloco in linha:
                    cont_bloco+=1
                    try:
                        if is_over((x_bola+11.5, y_bola+11.5), bloco_1, (bloco[1][0],bloco[1][1])):
                            matriz_inicio[cont][cont_bloco]=0
                            y_bola=671
                            quebra_bloco.play(0)
                            for img in explosao_imgs:
                                screen.blit(img, (bloco[1][0]-10,bloco[1][1]))
                                pygame.display.flip()
                                pygame.time.wait(10)
                    except:
                        None
            cont = -1
            for coluna in matriz_centro:
                cont_bloco=-1
                cont+=1
                for bloco in coluna:
                    cont_bloco+=1
                    try:
                        if is_over((x_bola+11.5, y_bola+11.5), bloco_1, (bloco[1][0],bloco[1][1])):
                            del matriz_centro[cont][cont_bloco]
                            y_bola=671
                            quebra_bloco.play(0)
                            for img in explosao_imgs:
                                screen.blit(img, (bloco[1][0]-10,bloco[1][1]))
                                pygame.display.flip()
                                pygame.time.wait(10)
                    except:
                        None
            cont = -1
            for linha in matriz_fim:
                cont_bloco=-1
                cont+=1
                for bloco in linha:
                    cont_bloco+=1
                    try:
                        if is_over((x_bola+11.5, y_bola+11.5), bloco_1, (bloco[1][0],bloco[1][1])):
                            matriz_fim[cont][cont_bloco]=0
                            y_bola=671
                            quebra_bloco.play(0)
                            for img in explosao_imgs:
                                screen.blit(img, (bloco[1][0]-10,bloco[1][1]))
                                pygame.display.flip()
                                pygame.time.wait(10)
                    except:
                        None
            if is_over((x_bola, y_bola), base_2, (posicao_p2, y_base_2)) or is_over((x_bola+23, y_bola), base_2, (posicao_p2, y_base_2)):
                base_2 = 0
                topo_rotacionado_2 = 0
                explosao = True
                primeira_rodada = False
                player_1_win = True

            elif is_over((x_bola, y_bola), base_1, (posicao_p1, y_base_1)) or is_over((x_bola+23, y_bola), base_1, (posicao_p1, y_base_1)):
                base_1 = 0
                topo_rotacionado = 0
                explosao = True
                player_2_win = True
        
        pygame.display.update()
        
if __name__ == '__main__':
    game()